System and method for reconstructable all-in-one content stream

ABSTRACT

One embodiment provides a system for assembling a reconstructable content stream. The system obtains a content collection that includes a plurality of content components and generates a manifest. An entry in the manifest corresponds to a content component. The system obtains a set of stream-construction rules, generates a stream-construction manifest by attaching the set of stream-construction rules to the manifest, and constructs a set of stream objects based on the stream-construction rules. A respective stream object may include an embedded chunk of a content component. The system signs the set of stream objects and assembles the reconstructable content stream by including the stream-construction manifest followed by the set of stream objects, thereby enabling an intermediate node to extract and store one or more content components and to reconstruct, at a later time, stream objects for the one or more content components based on the stream-construction manifest and the stored components.

RELATED APPLICATIONS

The subject matter of this application is related to the subject matterin the following applications:

-   -   U.S. patent application Ser. No. 14/334,386, entitled        “RECONSTRUCTABLE CONTENT OBJECTS,” by inventor Marc E. Mosko,        filed 17 Jul. 2014; and    -   U.S. patent application Ser. No. 14/463,450, entitled “SYSTEM        AND METHOD FOR ALL-IN-ONE CONTENT STREAM IN CONTENT-CENTRIC        NETWORKS,” by inventors Marc E. Mosko and Ignacio Solis, filed        19 Aug. 2014;        the disclosures of which are herein incorporated by reference in        their entirety.

BACKGROUND

1. Field

The present disclosure relates generally to a content-centric network(CCN). More specifically, the present disclosure relates to a system andmethod for downloading a set of Content Objects using a single namedstream in content-centric networks (CCNs).

2. Related Art

The proliferation of the Internet and e-commerce continues to fuelrevolutionary changes in the network industry. Today, a significantnumber of information exchanges, from online movie viewing to daily newsdelivery, retail sales, and instant messaging, are conducted online. Anincreasing number of Internet applications are also becoming mobile.However, the current Internet operates on a largely location-basedaddressing scheme. The two most ubiquitous protocols, Internet Protocol(IP) and Ethernet protocol, are both based on end-host addresses. Thatis, a consumer of content can only receive the content by explicitlyrequesting the content from an address (e.g., IP address or Ethernetmedia access control (MAC) address) that is typically associated with aphysical object or location. This restrictive addressing scheme isbecoming progressively more inadequate for meeting the ever-changingnetwork demands.

Recently, information-centric network (ICN) architectures have beenproposed in the industry where content is directly named and addressed.Content-Centric networking (CCN), an exemplary ICN architecture, bringsa new approach to content transport. Instead of viewing network trafficat the application level as end-to-end conversations over which contenttravels, content is requested or returned based on its unique name, andthe network is responsible for routing content from the provider to theconsumer. Note that content includes data that can be transported in thecommunication system, including any form of data such as text, images,video, and/or audio. A consumer and a provider can be a person at acomputer or an automated process inside or outside the CCN. A piece ofcontent can refer to the entire content or a respective portion of thecontent. For example, a newspaper article might be represented bymultiple pieces of content embodied as data packets. A piece of contentcan also be associated with metadata describing or augmenting the pieceof content with information such as authentication data, creation date,content owner, etc.

In CCN, names play an important role. More specifically, Content Objectsand Interests are identified by their name, which is typically ahierarchically structured variable-length identifier (HSVLI). Interestsand Content Objects flow through the network based on their names. Whendownloading named content, which can be a file library or a web page,the requester often needs to issue an initial set of Interest messagesto obtain the catalog of the library or the markup document of the webpage. In the case of a web page, upon receiving the markup document, therequester needs to parse the markup document, and then start downloadingembedded objects referenced by the markup document. Such a process oftenrequires more than one round-trip time (RTT), thus adding significantlatency to the content download process. This problem is similar to thedownload-latency problem experienced by IP networks.

In the IP world, people have not been satisfied with the performance ofHypertext Transfer Protocol (HTTP), because although very efficient attransferring individual files, HTTP cannot efficiently transfer a largenumber of small files. However, today's web destinations often includepages with tens of, or more, embedded objects, such as images, cascadingstyle sheet (CSS) files, and external JavaScript files. Loading allthese individual files takes time because of all the overhead ofseparately requesting them and waiting for the TCP (Transmission ControlProtocol) sessions to probe the network capacity and ramp up theirtransmission speed. For example, when requesting web content using HTTPover TCP, the requester typically has to wait for a three-way TCPhandshake to be completed to send a GET request before beginning todownload the desired HTTP and HTML markup document. Then, after parsingthe markup document, the requester can request the individual embeddedobjects. To reduce such download latency, certain “zero round-trip time”protocols have been developed in the IP setting, such as SPTY™(registered trademark of Google Inc. of Menlo Park, Calif.) developed byGoogle. However, no such solutions exist in CCN settings.

SUMMARY

One embodiment of the present invention provides a system for assemblinga reconstructable content stream and delivering the reconstructablecontent stream over a network. During operation, the system obtains acontent collection that includes a plurality of content components andgenerates a manifest for the content collection. A respective entry inthe manifest corresponds to a content component. The system obtains aset of stream-construction rules, generates a stream-constructionmanifest by attaching the set of stream-construction rules to themanifest, and constructs a set of stream objects for the contentcollection based on the set of stream-construction rules. A respectivestream object may include an embedded chunk of a content component. Thesystem further cryptographically signs the set of stream objects andassembles the reconstructable content stream by including thestream-construction manifest followed by the set of stream objects,thereby enabling an intermediate node in the network to extract andstore embedded chunks of one or more content components and toreconstruct, at a later time, stream objects for the one or more contentcomponents based on the stream-construction manifest and the storedembedded chunks.

In a variation on this embodiment, the set of stream-construction rulesincludes one or more of: a rule that defines a naming convention for theset of stream objects, a rule that specifies a signing key, and a rulethat specifies whether to include cryptographic signatures for the setof stream objects in the stream-construction manifest.

In a variation on this embodiment, a respective content componentincludes multiple chunks spanning multiple stream objects, and acorresponding entry in the manifest lists hash values of the multiplechunks embedded in the multiple stream objects.

In a further variation, the stream-construction manifest furthercomprises a cryptographic signature generated over thestream-construction manifest, thereby enabling a recipient of a streamobject to authenticate the set of stream objects based on thecryptographic signature.

In a variation on this embodiment, the network is a content-centricnetwork, and the stream objects are standard CCN Content Objects.

One embodiment of the present invention provides a system forreconstructing one or more stream objects that belong to a contentstream for downloading a content collection. During operation, thesystem receives, from a provider of the content collection, an initialset of stream objects of the content stream. The initial set of streamobjects includes a stream-construction manifest, and thestream-construction manifest includes a set of stream-construction rulesand a set of entries corresponding to content components in the contentcollection. In response to determining that a content component includedin the content collection exists in a local cache, the systemreconstructs one or more stream objects for the content component basedon the set of stream-construction rules, and inserts the reconstructedone or more stream objects into the content stream.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 illustrates an exemplary architecture of a network, in accordancewith an embodiment of the present invention.

FIG. 2 presents a diagram illustrating the format of a conventionalmanifest.

FIG. 3A presents a diagram illustrating the various components includedin a web page.

FIG. 3B presents a diagram illustrating a conventional process ofdownloading a web page with embedded objects.

FIG. 4 presents a diagram illustrating the format of an exemplaryall-in-one manifest, in accordance with an embodiment of the presentinvention.

FIG. 5 presents a diagram illustrating the format of exemplary ContentObjects in the all-in-one stream, in accordance with an embodiment ofthe present invention.

FIG. 6 presents a diagram illustrating an exemplary process ofdownloading a content collection using an all-in-one stream, inaccordance with an embodiment of the present invention.

FIG. 7 presents a diagram illustrating an exemplary recursive all-in-onestream, in accordance with an embodiment of the present invention.

FIG. 8 presents a diagram illustrating an exemplary all-in-one streamwith a multiple-section manifest, in accordance with an embodiment ofthe present invention.

FIG. 9 presents a diagram illustrating a process of constructing anall-in-one stream that can be used to download a content collection, inaccordance with an embodiment of the present invention.

FIG. 10 presents a diagram illustrating an exemplary stream-constructionmanifest, in accordance with an embodiment of the present invention.

FIG. 11 presents a diagram illustrating how to construct a streamContent Object, in accordance with an embodiment of the presentinvention.

FIG. 12 presents a flowchart illustrating an exemplary process ofconstructing a reconstructable all-in-one stream, in accordance with anembodiment of the present invention.

FIG. 13 presents a flowchart illustrating an exemplary process ofreconstructing an all-in-one stream, in accordance with an embodiment ofthe present invention.

FIG. 14 illustrates an exemplary system that enables a reconstructableall-in-one stream for content download, in accordance with an embodimentof the present invention.

In the figures, like reference numerals refer to the same figureelements.

DETAILED DESCRIPTION Overview

Embodiments of the present invention provide a system and method fordownloading a set of embedded objects (content component) using areconstructable all-in-one stream. The reconstructable all-in-one streamallows a forwarder that has an embedded object in its cache to constructa set reconstructable Content Objects from its cached embedded objectbased on information carried in a special manifest, also known as astream-construction manifest. The stream-construction manifest includesa normal all-in-one manifest plus stream-construction rules, metadata,and cryptographic signatures. This allows the forwarder to skip theprocess of obtaining the stream wrapper for cached embedded objects. Inaddition, the stream-construction manifest can serve as a secure catalogand carry all signatures for the entire stream.

In general, CCN uses two types of messages: Interests and ContentObjects. An Interest carries the hierarchically structuredvariable-length identifier (HSVLI), also called the “name” or the “CCNname” of a Content Object and serves as a request for that object. If anetwork element (e.g., router) receives multiple Interests for the samename, it may aggregate those Interests. A network element along the pathof the Interest with a matching Content Object may cache and return thatobject, satisfying the Interest. The Content Object follows the reversepath of the Interest to the origin(s) of the Interest. A Content Objectcontains, among other information, the same HSVLI, the object's payload,and cryptographic information used to bind the HSVLI to the payload.

The terms used in the present disclosure are generally defined asfollows (but their interpretation is not limited to such):

-   -   “HSVLI:” Hierarchically structured variable-length identifier,        also called a “name.” It is an ordered list of name components,        which may be variable length octet strings. In human-readable        form, it can be represented in a format such as ccnx:/path/part.        Also the HSVLI may not be human-readable. As mentioned above,        HSVLIs refer to content, and it is desirable that they be able        to represent organizational structures for content and be at        least partially meaningful to humans. An individual component of        an HSVLI may have an arbitrary length. Furthermore, HSVLIs can        have explicitly delimited components, can include any sequence        of bytes, and are not limited to human-readable characters. A        longest-prefix-match lookup is important in forwarding packets        with HSVLIs. For example, an HSVLI indicating an Interest in        “/parc/home/bob” will match both “/parc/home/bob/test.txt” and        “/parc/home/bob/bar.txt.” The longest match, in terms of the        number of name components, is considered the best because it is        the most specific. Detailed descriptions of HSVLIs can be found        in U.S. Pat. No. 8,160,069, entitled “SYSTEM FOR FORWARDING A        PACKET WITH A HIERARCHICALLY STRUCTURED VARIABLE-LENGTH        IDENTIFIER,” by inventors Van L. Jacobson and James D. Thornton,        filed 23 Sep. 2009, the disclosure of which is incorporated        herein by reference in its entirety.    -   “Interest:” A request for a Content Object. The Interest        specifies an HSVLI name prefix and other optional selectors that        can be used to choose among multiple objects with the same name        prefix. Any Content Object whose name matches the Interest name        prefix (and, optionally, other requested parameters such as        publisher key-ID match) satisfies the Interest.    -   “Content Object:” A data object sent in response to an Interest.        It has an HSVLI name and a content payload that are bound        together via a cryptographic signature. Optionally, all Content        Objects have an implicit terminal name component made up of the        SHA-256 digest of the Content Object. In one embodiment, the        implicit digest is not transferred on the wire, but is computed        at each hop, if needed. Note that the Content Object is not the        same as a content component. A Content Object has a specifically        defined structure under the CCN protocol and its size is        normally the size of a network packet (around 1500 bytes for        wide area networks and 8000 bytes for local area networks and        with fragmentation), whereas a content component is a general        term used to refer to a file of any type, which can be an        embedded object of a web page. For example, a web page may        include a number of embedded objects, such as image, video        files, or interactive components. Each embedded object is a        content component and may span multiple Content Objects.

As mentioned before, an HSVLI indicates a piece of content, ishierarchically structured, and includes contiguous components orderedfrom a most general level to a most specific level. The length of arespective HSVLI is not fixed. In content-centric networks, unlike aconventional IP network, a packet may be identified by an HSVLI. Forexample, “abcd/bob/papers/ccn/news” could be the name of the content andidentifies the corresponding packet(s), i.e., the “news” article fromthe “ccn” collection of papers for a user named “Bob” at theorganization named “ABCD.” To request a piece of content, a nodeexpresses (e.g., broadcasts) an Interest in that content by thecontent's name. An Interest in a piece of content can be a query for thecontent according to the content's name or identifier. The content, ifavailable in the network, is sent back from any node that stores thecontent to the requesting node. The routing infrastructure intelligentlypropagates the Interest to the prospective nodes that are likely to havethe information and then carries available content back along thereverse path traversed by the Interest message. Essentially the ContentObject follows the breadcrumbs left by the Interest message and thusreaches the requesting node.

FIG. 1 illustrates an exemplary architecture of a network, in accordancewith an embodiment of the present invention. In this example, a network180 comprises nodes 100-145. Each node in the network is coupled to oneor more other nodes. Network connection 185 is an example of such aconnection. The network connection is shown as a solid line, but eachline could also represent sub-networks or super-networks, which cancouple one node to another node. Network 180 can be content-centric, alocal network, a super-network, or a sub-network. Each of these networkscan be interconnected so that a node in one network can reach a node inother networks. The network connection can be broadband, wireless,telephonic, satellite, or any type of network connection. A node can bea computer system, an endpoint representing users, and/or a device thatcan generate Interest or originate content.

In accordance with an embodiment of the present invention, a consumercan generate an Interest for a piece of content and forward thatInterest to a node in network 180. The piece of content can be stored ata node in network 180 by a publisher or content provider, who can belocated inside or outside the network. For example, in FIG. 1, theInterest in a piece of content originates at node 105. If the content isnot available at the node, the Interest flows to one or more nodescoupled to the first node. For example, in FIG. 1, the Interest flows(Interest flow 150) to node 115, which does not have the contentavailable. Next, the Interest flows (Interest flow 155) from node 115 tonode 125, which again does not have the content. The Interest then flows(Interest flow 160) to node 130, which does have the content available.The flow of the Content Object then retraces its path in reverse(content flows 165, 170, and 175) until it reaches node 105, where thecontent is delivered. Other processes such as authentication can beinvolved in the flow of content.

In network 180, any number of intermediate nodes (nodes 100-145) in thepath between a content holder (node 130) and the Interest generationnode (node 105) can participate in caching local copies of the contentas it travels across the network. Caching reduces the network load for asecond subscriber located in proximity to other subscribers byimplicitly sharing access to the locally cached content.

The Manifest

In CCN, a manifest (also known as a catalog) is used to represent acollection of data. For example, a CCN node may contain a videocollection that includes a large number of video files, and the manifestof the video collection can be an ordered list identifying the ContentObjects corresponding to the video files. Note that, due to the sizelimit of a Content Object, a video file may span multiple ContentObjects. Moreover, a CCN node may store content for a web page, and themanifest for the web page identifies the different components of the webpage, such as the markup document and embedded objects (including Javascripts, image files, audio files, video files, etc.).

In the manifest, each Content Object is identified by its name andcorresponding digest, where the digest is the hash value (often computedusing a cryptographic hash function, such as hash function SHA-256) ofthe Content Object. In some embodiments, each Content Object is alsoidentified by a modified time indicating the time that the content wasmodified. FIG. 2 presents a diagram illustrating the format of aconventional manifest (prior art).

In FIG. 2, manifest 200 includes an ordered list of Content Objectsidentified by a collection name 204 and one or more of the following: aContent Object name 230.1-230.n; a digest 232.1-232.n; and a modifiedtime 234.1-234.n. The digests 232.1-232.n include a hash value of theContent Object identified respectively by names 230.1-230.n. Manifest200 also includes a root hash 202, which is an additive hash value basedon the hash values 232.1-232.n of the individual Content Objects in thecollection. Root hash 202 of manifest 200 is a unique identifier formanifest 200.

As shown in FIG. 2, manifest 200 can indicate a name and correspondingdigest for each Content Object represented in the collection.Optionally, manifest 200 can also include a modified time for eachContent Object represented in the collection. The use of the modifiedtime field depends on the underlying application or service beingperformed. In addition to an ordered list, the manifest may also bestructured as a synchronization tree, which contains Content Objects aswell as nested collections of Content Objects.

In conventional CCNs, when a content requester requests a contentcollection, such as a web page, the requester needs to issue an initialset of Interest messages to read a piece of the content. FIG. 3Apresents a diagram illustrating the various components included in a webpage. In FIG. 3A, a web page 300 includes a markup document 302 and anumber of objects referenced by markup document 302, such as JavaScriptfiles 304 (File1.js) and 306 (File2.js) and embedded images 308(image 1) and 310 (image N). In order to download entire web page 300, arequester first needs to request markup document 302, and then it needsto parse markup document 302 to get information about the embeddedobjects in order to request those objects, such as JavaScript files 304and 306 or images 308 and 310.

FIG. 3B presents a diagram illustrating a conventional process ofdownloading a web page with embedded objects. In FIG. 3B, a requester312 is downloading a web page that includes multiple embedded objectsfrom one or more responders 314. During operation, requester 312 startsthe downloading process by issuing a set of Interest messages 316 toresponder 314 to request the markup document. Upon retrieving the markupdocument, requester 312 parses the markup document, and then requeststhe embedded objects (which can be a JavaScript file or an image) one byone. This results in the staggered requesting and downloading of theembedded objects, thus increasing latency. Moreover, because requester312 does not know a priori how many chunks to request for an embeddedobject, it may send an estimated number of Interests to request theobject, which may be too few or too many. For example, in FIG. 3B,Interest set 316 for the markup document includes four Interests, eachwith the same name prefix but different chunk numbers (such as/foo/page/s0, /foo/page/s1, . . . , /foo/page/s3). However, the numberof issued Interests is less than the number of segments (chunks)included in markup document 302. Upon receiving the initial segments,requester 312 issues additional Interests for the rest of markupdocument 302. Upon receiving all segments (including a Content Objectset 318 and a Content Object set 320) of markup document 302, requester312 reads the markup document and requests the embedded objects(operation 322).

To request JavaScript file 304 (File1.js), requester 312 sends a set ofInterest messages 324. Without a priori knowledge of the size ofFile1.js, requester 312 may open too large a window by issuing too manyInterests. In FIG. 3B, requester 312 issues four Interests for File1.js,each with the same name prefix but different chunk numbers (such as/foo/File1.js/s0, /foo/File1.js/s1, . . . , /foo/File1.js/s3). However,File1.js contains only two segments, and returns a Content Object set326 that includes only two Content Objects. Therefore, the extra twoInterests sent from requester 312 for File1.js are wasted, and couldhave been used to request useful content, such as being used to startdownloading JavaScript file 306 (File2.js). Similarly, requester 312 mayagain issue four Interests for JavaScript file 306 (File2.js), which hasonly one segment, meaning that three Interests are wasted. For contentcollections that include many small objects, this over-requesting cansignificantly reduce the overall throughput of the network.

In order to reduce the download latency and to improve throughput, insome embodiments, the system aggregates all the necessary content(including the markup document and all embedded objects) into a singlenamed stream, and allows a requester to download all the necessarycontent using the single named stream, also known as an all-in-onestream. In some embodiments, this single named stream (the all-in-onestream) for a content collection includes an all-in-one manifestfollowed by the embedded objects. Note that, in order to facilitatedownloading with the all-in-one stream, changes need to be made to aconventional manifest (as shown in FIG. 2) to obtain an all-in-onemanifest. More specifically, the all-in-one manifest needs to specifythe number of segments contained in each embedded object.

FIG. 4 presents a diagram illustrating the format of an exemplaryall-in-one manifest, in accordance with an embodiment of the presentinvention. In FIG. 4, a content collection (which can include allcontent of a web page) 400 includes a manifest 402, a markup document404, a JavaScript file (File1.js) 406, a JavaScript file (File2.ls) 408,and other components. Manifest 402 includes an ordered list of contentcomponents, with each entry corresponding to one content component,which can be a markup document or an embedded object. Each entryincludes an object name field that specifies the CCN name of the contentcomponent, a chunk-number field that lists the sequence of the chunks ofthe content component within the all-in-one stream, and a chunk-hashfield that lists the hash values of all the chunks.

For example, in FIG. 4, entry 410 included in manifest 402 correspondsto markup document 404. More specifically, entry 410 includes an objectname field 412.1, a chunk-number field 414.1, and a chunk-hash field416.1. Object name field 412.1 specifies the CCN base name (/foo/markup)of markup document 404. Chunk-number field 414.1 specifies that markupdocument 404 (identified by the CCN name 412.1) occupies chunks s3-s9(seven chunks in total with each chunk being an individual ContentObject) of the all-in-one stream. Note that, in some embodiments, theCCN name of each chunk (or each Content Object) can be constructed asthe CCN base name of the content component plus the chunk number. Forexample, the first chunk of markup document 404 can have a CCN name/foo/markup/s0, and the last chunk can have a CCN name /foo/markup/s6,given that markup document 404 has seven chunks. Chunk-hash field 416.1lists the Content Object hash values (such as 0x12AB, 0x7798, etc.) ofall seven chunks. Note that in the example shown in FIG. 4, the ContentObject hash values are shown as 2-byte hashes for viewing simplicity. Inpractice, the Content Object hash of a Content Object can be a 16-bytehash value calculated using a SHA-256 function or its equivalent.

Also shown in FIG. 4, entry 420 included in manifest 402 corresponds toJavaScript file 406 (File1.js). Similar to entry 410, entry 420 includesan object name field 412.2, a chunk-number field 414.2, and a chunk-hashfield 416.2. More specifically, object name field 412.2 specifies thatthe CCN name for JavaScript file 406 is /foo/file1.js, chunk-numberfield 414.2 specifies that JavaScript file 406 has two chunks (s10 ands11), and chunk-hash field 416.2 lists the Content Object hash valuesfor those two chunks (0xD2A0, 0x3333).

Note that unlike conventional manifests, manifest 402 enumerates thechunk ranges (or offset) of each embedded object in the all-in-onestream. This allows the requester of the content to determine whetherthe object (content component) is already covered by the outstandingInterest window. For example, if 10 Interests have been issued, then the10^(th) chunk has been covered by the issued Interests. In addition,including the Content Object hash of each chunk in the manifest 402allows the requester to determine whether it already has an object or asegment of the object in its cache by comparing the Content Object hashvalues. If an object is not yet covered by an outstanding request andthe requestor already has the object in its cache, the requester canskip the download of that embedded object. For example, embeddedJavaScript file 406 ranges from s10 to s11 in the all-in-one stream, andif an initial request issues Interests up to chunk 9, then JavaScriptfile 406 is not covered by the initial request. In addition, based onthe Content Object hashes of JavaScript file 406, the requester maydetermine that it already has JavaScript file 406 in its cache. Hence,the requester can then skip the download of JavaScript file 406 whilecontinuing to download subsequent content components within contentcollection 400.

Moreover, listing the Content Object hashes of each content componentallows a requester to open up separate Interest windows for eachindividual content component and request them by their hashes. Morespecifically, the requester can request a particular embedded objectunder its own name, using a self-certified Content Object hash name. Forexample, the requester may request JavaScript file 406 by the hashes ofits two segments, 0xD2A0 and 0x3333. In other words, in addition toenabling content download using a single all-in-one stream, theall-in-one manifest also enables a requester to download contentcomponents using a set of parallel streams that are independent of eachother. Hence, instead of waiting to parse the markup document beforedownloading the embedded objects, the requester can download the markupdocument and the embedded documents in parallel. Each stream request canbe based on the hash name of the embedded object. Downloading anembedded object using its own hash name also allows the download to comefrom some well-positioned caches, whereas downloading the embeddedobjects along with the markup document may result in their coming from aless optimal source. For example, image files may have very long cachelifetimes, so they can be cached in many places, while the frequentlyupdated web page (the markup) might have a short cache lifetime and iscached in few locations. In such situations, it is desirable to downloadthe images from a nearby cache location, instead of downloading themfrom the same location of the markup document, which can be far away.

The All-in-One Stream

FIG. 5 presents a diagram illustrating the format of exemplary ContentObjects in the all-in-one stream, in accordance with an embodiment ofthe present invention. More specifically, FIG. 5 shows how a contentcollection (such as content collection 400) can be assembled into asingle all-in-one stream that includes many chunks under the samenamespace, with each chunk being a standard CCN Content Object. In FIG.5, an all-in-one stream 500 includes a plurality of chunks, such aschunks 502, 504, 506, and 508. Each chunk is a standard CCN ContentObject conforming to the standard CCN Content Object format. EachContent Object includes at least a name component 512.x, a key-IDcomponent 514.x, a payload component 516.x, and a signature component518.x, with x corresponding to the sequence number of the chunk.

The name component specifies the CCN name of each chunk/Content Object.In some embodiments, all Content Objects within the all-in-one streamhave the same name prefix, and the CCN name of a Content Object is thename prefix plus its chunk number. In the example shown in FIG. 5, thename prefix of all Content Objects in all-in-one stream 500 is/foo/page/all-in-one, and the CCN name for Content Object 502 (which isthe first chunk, chunk 0, in all-in-one stream 500) is/foo/page/all-in-one/s0, as indicated by name component 512.1.Similarly, the CCN name for Content Object 504 (which is the secondchunk, chunk 1, in all-in-one stream 500) is /foo/page/all-in-one/s1, asshown by name component 512.2.

The key-ID component (514.x) within each Content Object identifies thepublic key used by the publisher to sign the Content Object. Thesignature component (518.x) can be obtained by signing, using thecorresponding private key, the remaining portions of the Content Object.In some embodiments, the signature can be obtained by signing over thehash of the remaining portions of the Content Object. For example, onecan obtain signature 518.1 by signing a hash value computed over namecomponent 512.1, key-ID component 514.1, and payload component 516.1.Note that, in some embodiments, not all Content Objects within theall-in-one stream contain the key-ID. At a minimum, the first ContentObject in the all-in-one stream should include the key-ID, or optionallycarry the public key, so that intermediate nodes and end systems canverify signatures.

The payload component (516.x) for each Content Object or chunk includeseither a portion of the manifest or a portion of an embedded contentcomponent, such as the markup document or a JavaScript file. The firstfew chunks (Content Objects) of the all-in-one stream often are wrappingobjects that represent the manifest of the stream, and the payload ofthese wrapping objects is the manifest itself. Depending on the size ofthe manifest, the wrapping objects may include fewer or more ContentObjects. In the example shown in FIG. 5, the manifest extends over threeContent Objects (chunks s0-s2), with each Object containing a chunk ofthe manifest. For example, payloads 516.1 and 516.2 include the firstand second chunks of the manifest, respectively.

The payloads of subsequent Content Objects include portions of thecontent components. For example, the payloads of Content Objects 506 and508 include embedded Content Objects /foo/markup/s0 and /foo/markup/s1,which are the first and second chunks of the markup document. Note that,although each embedded content component chunk itself may be a CCNContent Object that has its own name (such as /foo/markup/s0 in the caseof the chunk being part of the markup document), the correspondingContent Object assembled in the all-in-one stream is assigned its ownstream name, as indicated by name component 512.x. All Content Objectswithin the same all-in-one stream are assigned the same name prefix.Note that assigning the same name prefix to all Content Objects in theall-in-one stream allows a requester to open a large-enough window todownload all embedded content components continuously without the needto parse the markup document. For example, the requester can constructan initial set of Interests by sequentially adding the chunk number tothe name prefix, and using the initial set of Interests to request theembedded content components without needing to know the numbers, names,or sizes of those embedded content components within a contentcollection. For example, a requester can issue a set of Interests(/foo/page/all-in-one/s0, /foo/page/all-in-one/s1, . . . ,/foo/page/all-in-one/s19) to request the first 20 chunks of theall-in-one stream. Note that while downloading the chunks, the requestercan read the manifest (which is usually downloaded first) to determinewhether it needs to issue more Interests and whether it can skip thedownload of certain components because it already has them in its cache.

FIG. 6 presents a diagram illustrating an exemplary process ofdownloading a content collection using an all-in-one stream, inaccordance with an embodiment of the present invention. In FIG. 6, arequester 602 is downloading a web page that includes multiple embeddedobjects from one or more responders 604. To enable the all-in-onedownload, an all-in-one manifest has been created as a wrapper for thecontent of the web page.

During operation, requester 602 starts the downloading process byissuing an initial set of Interest messages 606 to responder 604. Thenumber of Interests included in initial set of Interest messages 606 canbe arbitrary. In some embodiments, this initial window (as defined byinitial Interest set 606) can be sufficiently large to cover all wrapperobjects, i.e., the manifest, but not larger than the entire contentcollection. In the example shown in FIG. 6, initial Interest set 606includes four Interests (/foo/page/all-in-one/s0 to/foo/page/all-in-one/s3), creating a download window large enough forthe retrieval of the manifest. Note that requester 602 can continue toissue new Interests (while reading the manifest) to request othercontent components, such as the markup document and the JavaScriptfiles, using the same name prefix (/foo/page/all-in-one). The newInterests can be created by sequentially adding the chunk numbers. Insome embodiments, while downloading, requester 602 reads the manifest,determines the total number of chunks included in the contentcollection, and issues a suitable number of Interests accordingly. Forexample, from reading the manifest, requester 602 may determine thatthere are 20 total chunks in the all-in-one stream, and ensure that itissues 20 Interests in total.

In addition, the requester can determine whether it already has one ormore content components or chunks in its cache based on the ContentObject hashes listed in the manifest, and if so, skip the download ofthese chunks. For example, by comparing the Content Object hashes, therequester may find that it already has JavaScript file File1.js, whichoccupies chunks s10 and s11 in the all-in-one stream. To improve thedownload efficiency, the requester can issue an Interest set thatexcludes Interests foo/page/all-in-one/s10 and /foo/page/all-in-one/s11.By doing so, the requester provides parameters to the responder so thatthe responder can configure which embedded objects to be included in thedownload stream. In this example, because the Interest set does not haveInterests for chunks s10 and s11, these two chunks are excluded from thedownload stream.

Comparing FIG. 6 to FIG. 3, one can see that there is no longer a needto stagger the download of the multiple embedded content components.Instead, in embodiments of the present invention, the download of thecontent collection can be accomplished using a single stream, thuspotentially significantly reducing the download latency. Moreover,because the manifest lists the total number of chunks included in thedownload stream, there is no need for the requester to over-request, andno Interests will be wasted, thus increasing the system throughput.

In some embodiments, an object embedded in the payload of a stream chunkmay also be an all-in-one stream itself. For example, an HTML file mayreference frames of other HTML files or other objects, which couldthemselves be organized as an all-in-one stream. FIG. 7 presents adiagram illustrating an exemplary recursive all-in-one stream, inaccordance with an embodiment of the present invention. In FIG. 7,all-in-one stream 700 includes a manifest 702 and a number of contentcomponents, such as a markup document 704, embedded objects 706 and 708,etc. More specifically, embedded object 708 itself is an all-in-onestream, which includes a manifest 712 and other content components, suchas an embedded object 714. Note that, in such a situation, the parentmanifest (manifest 702) treats embedded all-in-one stream 708 the sameway as any other embedded objects by listing its stream name, range ofchunks, and hash values of its chunks. Note that the correspondingContent Objects included in all-in-one stream 700, including the ContentObjects carrying embedded all-in-one stream 708, are given the nameprefix of all-in-one stream 700.

A content collection may include many embedded objects and each embeddedobject may span many Content Objects, such as a web page that contains alarge number of high-resolution images. In such a situation, listing allembedded objects in a single manifest may result in the manifest beingtoo big itself for efficient download. To improve manifest-downloadefficiency, in some embodiments, a large manifest that lists manyembedded objects may be reorganized into a number of smaller manifestsscattered at different locations within the all-in-one stream. FIG. 8presents a diagram illustrating an exemplary all-in-one stream with amultiple-section manifest, in accordance with an embodiment of thepresent invention. In FIG. 8, all-in-one stream 800 includes a number ofmanifest sections, such as an initial manifest section 802 and manifestsections 804 and 806; and a number of content components, such as amarkup document 808, image files 810 and 812, etc. Instead of listingall embedded objects in initial manifest section 802, initial manifestsection 802 may only contain information of markup document 808 and apointer to a subsequent manifest, manifest section 804. This allows therequester to download, using an initial Interest window, initialmanifest 802 and markup document 808, which include important web pageinformation. The pointer included in initial manifest 802 enables therequester to request the subsequent manifest section. Organizing themanifest into multiple sections allows the requester to downloadportions of a web page while determining whether it has certain embeddedobjects in its cache already, and to skip downloading such objects ifthey are in the local cache.

In situations where large content components (such as high-resolutionimages) exist, instead of listing Content Object hash values of allContent Objects in the manifest, the manifest may list only a fewinitial Content Object hashes of each embedded object. For example, anembedded image may span a few hundred Content Objects; instead oflisting the hash values of these hundreds of Content Objects, themanifest may only list the initial few (such as 10%) hash values. Thesefew hash values should provide enough information to allow a requesterto determine whether it already has the image in its cache or to begindownloading the image, maybe from a nearby location, under its own namespace.

In some embodiments, the Interest messages can include a “modifiedsince” parameter. Therefore, when such Interests are received, theresponder includes, in the all-in-one stream and/or its manifest, onlyembedded objects that are modified after the “modified since” parameter.This allows a requester to skip the downloading of old files, such asold photos, while downloading a web page. In a variation, the all-in-onestream can include older objects that are newly referenced. For example,if an old photo has not been included in the web page manifest in a longtime, it may be included in the all-in-one stream even though it has notbeen modified since the “modified since” parameter specified in theInterests.

In some embodiments, the all-in-one stream can be compressed.

FIG. 9 presents a diagram illustrating an exemplary process ofconstructing an all-in-one stream that can be used to download a contentcollection, in accordance with an embodiment of the present invention.During operation, the content provider, such as a publisher, constructsan all-in-one manifest for the content collection (operation 902). Insome embodiments, the manifest includes an ordered list of contentcomponents within the collection. Each entry in the ordered listincludes an object name field that specifies the CCN name of acorresponding content component, a chunk-number field that lists thechunk numbers occupied by the content component within the all-in-onestream, and a chunk-hash field that lists the hash values of the firstfew or all chunks of the content component.

The content provider further packages the constructed manifest alongwith the content components into standard Content Objects (operation904). In some embodiments, the Content Objects conform to CCN standards.Note that each Content Object is assigned a stream name, and all ContentObjects in the stream have the same name prefix. Subsequently, thecontent provider receives a set of initial Interest requests under thename space of the stream (operation 906), and in response, the contentprovider constructs a stream of Content Objects, starting with themanifest, based on the received Interests and parameters included in theinitial Interest requests (operation 908). In some embodiments, theparameters included in the Interest requests may include a “modifiedsince” parameter. Note that once the requester receives the manifest, itmay include, in subsequent Interests, parameters that are determinedbased on information included in the manifest. For example, therequester may skip one or more content components based on the hasheslisted in the manifest, which may indicate that those components are inthe requester's cache already.

The content provider continues to receive Interests from the requester(operation 910), determines the content components to be included in thestream based on the received Interests (operation 912), and continuouslyconstructs the stream by including the appropriate components (operation914).

The Reconstructable All-in-One Stream

In some embodiments of the present invention, the all-in-one stream caninclude reconstructable Content Objects. A reconstructable ContentObject is constructed from a content piece based on a set of rulesstored in a metadata file, and may include a cryptographic signatureprovided by the original publisher. To enable a recipient to reconstructthe Content Object, the reconstructable Content Object is transferredover the network along with the metadata file. The recipient extractsand saves the payload (in the form of a user file) and the signature,and discards the received Content Object. When needed, the recipient canreconstruct the original Content Object from the saved user file usingthe signature and information included in the metadata file. A detaileddescription of the reconstructable Content Object can be found in U.S.Pat. application Ser. No. 14/334,386, entitled “RECONSTRUCTABLE CONTENTOBJECTS,” by inventor Marc E. Mosko, filed 17 Jul. 2014, the disclosureof which is incorporated herein by reference in its entirety.

As disclosed in the previous section, when a content requester requestsa web page that contains multiple embedded objects, the contentrequester may open an initial window (by issuing an initial set ofInterests) to download the web page along with the embedded objects in asingle all-in-one stream. As shown in FIG. 5, the payload of the initialone or more stream Content Objects may include chunks of the all-in-onemanifest, which enumerates the stream chunks for each embedded objectand the hash values of all the chunks. Starting from the responder, thesingle all-in-one stream (and, thus, the stream Content Objects) maypass through multiple network nodes, such as routers, before they reachthe requester. In CCN, it is desirable to have the intermediate nodescache the all-in-one stream in its local content store such that it canrespond to future requests to the web page. However, storing theall-in-one stream means storing stream Content Objects in a format shownin FIG. 5, such as Content Objects 502-508. Note that, as one can seefrom FIG. 5, Content Objects representing a content component, such as amarkup document or an image file, are wrapped around by the streamwrapper, the name and the signature field. Hence, if a differentrequester attempts to request an individual embedded object, such as animage file, the router caching the all-in-one stream cannot respondbecause it is not aware of the embedded object in the stream ContentObjects, unless the router removes the stream wrapper and extracts thepayload, which is the embedded Content Objects. Therefore, in order tobe able to respond to requests for the entire content piece that hasembedded objects, as well as requests for individual embedded objects,the router may need to store the content piece in both forms, one as anall-in-one stream that includes a plurality of stream Content Objects,and one as individual embedded objects. For example, the router canextract payloads from the all-in-one stream, and store each individualembedded object, such as a JavaScript file or an image file, separately.Similarly, if the end node receiving the content piece (such as a webpage) wants to respond to future requests, both the web page and anyindividual components may need to store the content piece in both forms.

However, storing the same content piece in two forms can result inundesired redundancy in data storage on the intermediate node,especially for a content piece that includes many embedded objects. Toavoid such redundancy, in some embodiments of the present invention, thesystem generates and delivers reconstructable all-in-one streams, whichallow an intermediate node to store the content piece as individualembedded objects and reconstruct the all-in-one stream when it receivesa future request for the content piece. Note that each individualembedded object may span multiple standard CCN Content Objects that havethe same CCN base name.

In order to enable an intermediate node to reconstruct the all-in-onestream, in some embodiments, the original node that initiates theall-in-one stream includes stream-construction information in theall-in-one manifest. Such a manifest is also known as astream-construction manifest. In some embodiments, thestream-construction manifest includes everything in the normalall-in-one manifest (as shown in FIG. 4), plus a set of rules forconstructing the all-in-one stream and a set of stream signatures.

FIG. 10 presents a diagram illustrating an exemplary stream-constructionmanifest, in accordance with an embodiment of the present invention. InFIG. 10, stream-construction manifest 1000 includes an all-in-onemanifest 1010, stream-construction metadata 1020, and a set of streamsignatures 1030. More specifically, all-in-one manifest 1010 is similarto all-in-one manifest 402 shown in FIG. 4, and includes an ordered listof the embedded objects. Stream-construction metadata 1020 includeswrapper information for the stream Content Objects. In some embodiments,stream-construction metadata 1020 may include a set of rules that isused to construct the all-in-one stream. For example, the metadata 1020can include a naming rule specifying how to name each stream chunk. Insome embodiments, the naming rule may specify a CCN base name.Additional rules may include a rule that specifies a signing key (suchas a key-ID identifying the public key), a rule that specifies whetherto include a corresponding public key in one or more stream chunks, arule that specifies whether to insert the stream signature in eachstream chunk or to keep the stream signatures in metadata 1020, etc. Insome embodiments, stream signatures 1030 include the stream signaturesof all chunks in the stream. In some embodiments, stream-constructionmanifest 1000 serves as a secure catalog, and stream signatures 1030includes a signature generated over stream-construction manifest 1000.In situations where stream-construction manifest serves as a securecatalog, the subsequent stream Content Objects no longer need to carrytheir own signatures, because all-in-one manifest 1010 contains the hashvalue of each stream chunk and a chain of trust can be formed. The chainof trust contains the manifest signature plus the hash chain to theembedded Content Objects.

Upon receiving the reconstructable all-in-one stream, the intermediatenode or the end node can store the stream-construction manifest,extracts and stores the embedded objects, and may discard the receivedall-in-one stream. If it receives a future Interest for a particularembedded object, such as an image, it can directly return thecorresponding embedded object. If it receives a future Interest for theentire content piece, it may reconstruct the all-in-one stream using thestored stream-construction manifest and the individual embedded objects.Moreover, if the content piece has been partially updated by the contentpublisher, the intermediate node may only fetch the updated portion (inthe form of an all-in-one) stream from the content publisher, and thenreconstruct stream Content Objects for the unchanged embedded objectsfrom its cache based on the stream-construction manifest. TheIntermediate node can then plug the reconstructed stream Content Objectsinto the all-in-one stream sent out from the publisher.

FIG. 11 presents a diagram illustrating how to construct a streamContent Object, in accordance with an embodiment of the presentinvention. In the example shown in FIG. 11, a device or a node isreconstructing a stream Content Object from an embedded Content Object1102 and a stream-construction manifest 1104. More specifically,embedded Content Object 1102 includes the first chunk of the markupdocument, hence the CCN name “/foo/markup/s0.” As disclosed previously,stream-construction manifest 1104 includes a set of rules forconstructing a stream Content Object. These rules allow the device ornode to generate the appropriate stream wrapper, which can include thename, the key information, and signatures. Note that the streamsignature is generated by the originator of the all-in-one stream, andis different from the signature included in each embedded ContentObject.

In the example shown in FIG. 11, reconstructed stream Content Object1110 is nearly identical to original stream Content Object 506 shown inFIG. 5, and includes a name field 1112, a key-ID field 1114, a payloadfield 1116, and a signature field 1118. However, in the example shown inFIG. 11, unlike the signature field in original stream Content Object506, signature field 1118 does not include the stream signature;instead, it may include a reference (as an implicit signature) toconstruct manifest 1104, which serves as a secure catalog and carries asignature for the secure catalog. Optionally, if aggregated signing isnot performed and stream-construction manifest 1104 does not act as asecure catalog, the device can extract an individual stream signaturecontained in construct manifest 1104 and insert it into reconstructedstream Content Object 1110.

In some embodiments, a device or a node may reconstruct the entireall-in-one stream, or it may reconstruct a number of stream ContentObjects and then insert them into a corresponding all-in-one stream.

In some embodiments, a device, such as a router or a forwarder, canproactively fetch embedded objects before a user requests them, and thenuse the reconstructable all-in-one stream to pass them to the user. Forexample, one or more popular images may be referenced by different webpages. To reduce future download latency, a router in the network mayproactively obtain those images even before a web page containing suchimages is being requested by a user. When a user requests such a webpage from the publisher of the web page, it may send Interests to thepublisher, which in turn constructs and returns an all-in-one stream. Onthe other hand, the router situated between the publisher and therequester, may detect, based on the stream-construction manifestincluded in the returned all-in-one stream, that it already has one ormore embedded images in its local cache and no longer needs to downloadthose images. Instead, the router can construct a number of streamContent Objects using the cached Content Objects that represent theembedded images. More specifically, the router can generate anappropriate stream wrapper for each embedded Content Object based on theset of stream-construction rules included in the stream-constructionmanifest, and then apply the wrapper to the embedded Content Object.After constructing the stream Content Objects, the router then insertsthe reconstructed stream Content Objects into the all-in-one stream sentout by the publisher of the web page.

In some embodiments, the stream-construction manifest may carry aglobally unique identifier (GUID) in its first Content Object that canbe used to uniquely identify the reconstructable all-in-one stream. Infurther embodiments, the GUID can be a hash value (such as a SHA-256hash) of the stream-construction manifest itself. This GUID allows anode in the network to determine whether the node has seen the samestream. If so, most likely the node already has all content componentsof the stream in its local cache, and can immediately satisfy allInterests in the all-in-one stream by reconstructing the entire stream.Note that the intermediate node can only do that if it can verify thesignature in the first Content Object.

FIG. 12 presents a flowchart illustrating an exemplary process ofconstructing a reconstructable all-in-one stream, in accordance with anembodiment of the present invention. During operation, a publisher of acontent collection that included multiple embedded objects constructs anall-in-one manifest (operation 1202). In some embodiments, theall-in-one manifest includes an ordered list of content componentswithin the collection. Each entry in the ordered list includes an objectname field that specifies the CCN name of a corresponding contentcomponent, a chunk-number field that lists the chunk numbers occupied bythe content component within the all-in-one stream, and a chunk-hashfield that lists the hash values of the first few or all chunks of thecontent component.

The publisher then obtains a set of stream-construction rules (operation1204). Note that the set of rules can either be default or defined bythe publisher. In some embodiments, the set of rules may specify how togenerate the stream wrapper for each embedded Content Object. Based onthe set of rules, the publisher generates a set of stream ContentObjects for the content collection (operation 1206), and creates acryptographic signature for each stream Content Object (operation 1208).The publisher can then generate a stream-construction manifest byincluding the all-in-one manifest, the set of stream-construction rules,and optionally the signatures (operation 1210), and place thestream-construction manifest at the beginning of the reconstructableall-in-one stream (operation 1212).

FIG. 13 presents a flowchart illustrating an exemplary process ofreconstructing an all-in-one stream, in accordance with an embodiment ofthe present invention. During operation, an intermediate node receives,from a provider of an all-in-one stream, an initial set of streamContent Objects (operation 1302). The intermediate node reads the firststream Content Object to extract a GUID (operation 1304), andauthenticates the first Content Object based on the stream signature(operation 1306). The intermediate node then determines whether theextracted GUID matched a GUID of a stream-construction manifest storedin its local cache (operation 1308). If so, the intermediate nodeaccesses the stored stream-construction manifest (operation 1310), andreconstructs the stream Content Objects using a set of cached contentcomponents (operation 1312). Subsequently, the intermediate nodeassembles an all-in-one stream by including the cachedstream-reconstruction manifest and the reconstructed stream ContentObjects (operation 1314), forwards the all-in-one stream to the streamrequester (operation 1316), and marks all Interests for the all-in-onestream as having been satisfied (operation 1318). If no GUID match isfound, the intermediate node continues to receive and forward theremaining stream Content Objects (operation 1320), and marks theInterests as satisfied when all stream Content Objects have beenforwarded to the stream requester (operation 1318).

Computer and Communication System

FIG. 14 illustrates an exemplary system that enables a reconstructableall-in-one stream for content download, in accordance with an embodimentof the present invention. A system 1400 that implements areconstructable all-in-one stream comprises a processor 1410, a memory1420, and a storage 1430. Storage 1430 typically stores instructionsthat can be loaded into memory 1420 and executed by processor 1410 toperform the methods mentioned above. In one embodiment, the instructionsin storage 1430 can implement a construction manifest generation module1432, a stream Content Object generation module 1434, and areconstructable all-in-one stream assembly module 1436, all of which canbe in communication with each other through various means.

In some embodiments, modules 1432, 1434, and 1436 can be partially orentirely implemented in hardware and can be part of processor 1410.Further, in some embodiments, the system may not include a separateprocessor and memory. Instead, in addition to performing their specifictasks, modules 1432, 1434, and 1436, either separately or in concert,may be part of general- or special-purpose computation engines.

Storage 1430 stores programs to be executed by processor 1410.Specifically, storage 1430 stores a program that implements a system(application) for enabling all-in-one content download. Duringoperation, the application program can be loaded from storage 1430 intomemory 1420 and executed by processor 1410. As a result, system 1400 canperform the functions described above. System 1400 can be coupled to anoptional display 1480 (which can be a touch screen display), keyboard1460, and pointing device 1470, and can also be coupled via one or morenetwork interfaces to network 1482.

The data structures and code described in this detailed description aretypically stored on a computer-readable storage medium, which may be anydevice or medium that can store code and/or data for use by a computersystem. The computer-readable storage medium includes, but is notlimited to, volatile memory, non-volatile memory, magnetic and opticalstorage devices such as disk drives, magnetic tape, CDs (compact discs),DVDs (digital versatile discs or digital video discs), or other mediacapable of storing computer-readable media now known or later developed.

The methods and processes described in the detailed description sectioncan be embodied as code and/or data, which can be stored in acomputer-readable storage medium as described above. When a computersystem reads and executes the code and/or data stored on thecomputer-readable storage medium, the computer system performs themethods and processes embodied as data structures and code and storedwithin the computer-readable storage medium.

Furthermore, methods and processes described herein can be included inhardware modules or apparatus. These modules or apparatus may include,but are not limited to, an application-specific integrated circuit(ASIC) chip, a field-programmable gate array (FPGA), a dedicated orshared processor that executes a particular software module or a pieceof code at a particular time, and/or other programmable-logic devicesnow known or later developed. When the hardware modules or apparatus areactivated, they perform the methods and processes included within them.

The above description is presented to enable any person skilled in theart to make and use the embodiments, and is provided in the context of aparticular application and its requirements. Various modifications tothe disclosed embodiments will be readily apparent to those skilled inthe art, and the general principles defined herein may be applied toother embodiments and applications without departing from the spirit andscope of the present disclosure. Thus, the present invention is notlimited to the embodiments shown, but is to be accorded the widest scopeconsistent with the principles and features disclosed herein.

What is claimed is:
 1. A computer-executable method for assembling areconstructable content stream and delivering the reconstructablecontent stream over a content centric network (CCN), comprising:generating, by a computer, a content manifest for a content collectioncomprising a plurality of content components, wherein a respective entryin the content manifest corresponds to a content component; generating astream-construction manifest by attaching a set of stream-constructionrules to the content manifest; constructing a first set of streamcontent objects based on the set of stream-construction rules, wherein arespective stream content object from the first set of stream contentobjects includes a chunk of the stream-construction manifest;constructing a second set of stream content objects for the contentcollection based on the set of stream-construction rules, wherein arespective stream content object from the second set of stream contentobjects includes a chunk of a content component, and wherein the firstset of stream content objects and the second set of stream contentobjects have a same name prefix; assembling the reconstructable contentstream by appending the second set of stream content objects to thefirst set of stream content objects, thereby enabling an intermediatenode in the network to extract and store chunks of one or more contentcomponents and to reconstruct, at a later time, stream content objectsfor the one or more content components based on the stream-constructionmanifest and the stored chunks.
 2. The method of claim 1, wherein theset of stream-construction rules includes one or more of: a rule thatdefines a naming convention for the set of stream content objects; arule that specifies a signing key; and a rule that specifies whether toinclude cryptographic signatures for the set of stream content objectsin the stream-construction manifest.
 3. The method of claim 1, wherein arespective content component includes multiple chunks spanning multiplestream content objects, and a corresponding entry in the contentmanifest lists hash values of the multiple chunks included in themultiple stream content objects.
 4. The method of claim 3, wherein thestream-construction manifest further comprises a cryptographic signaturegenerated over the stream-construction manifest, thereby enabling arecipient of a stream content object to authenticate the set of streamcontent objects based on the cryptographic signature.
 5. Anon-transitory computer-readable storage medium storing instructionsthat when executed by a computing device cause the computing device toperform a method for assembling a reconstructable content stream anddelivering the reconstructable content stream over a content-centricnetwork (CCN), the method comprising: generating a content manifest fora content collection comprising a plurality of content components,wherein a respective entry in the content manifest corresponds to acontent component; generating a stream-construction manifest byattaching a set of stream-construction rules to the content manifest;constructing a first set of stream content objects based on the set ofstream-construction rules, wherein a respective stream content objectfrom the first set of stream content objects includes a chunk of thestream-construction manifest; constructing a second set of streamcontent objects for the content collection based on the set ofstream-construction rules, wherein a respective stream content objectfrom the second set of stream content objects includes a chunk of acontent component, and wherein the first set of stream content objectsand the second set of stream content objects have a same name prefix;and assembling the reconstructable content stream by appending thesecond set of stream content objects to the first set of stream contentobjects, thereby enabling an intermediate node in the network to extractand store chunks of one or more content components and to reconstruct,at a later time, stream content objects for the one or more contentcomponents based on the stream-construction manifest and the storedchunks.
 6. The computer-readable storage medium of claim 5, wherein theset of stream-construction rules includes one or more of: a rule thatdefines a naming convention for the set of stream content objects; arule that specifies a signing key; and a rule that specifies whether toinclude cryptographic signatures for the set of stream content objectsin the stream-construction manifest.
 7. The computer-readable storagemedium of claim 5, wherein a respective content component includesmultiple chunks spanning multiple stream content objects, and acorresponding entry in the content manifest lists hash values of themultiple chunks included in the multiple stream content objects.
 8. Thecomputer-readable storage medium of claim 7, wherein thestream-construction manifest further comprises a cryptographic signaturegenerated over the stream-construction manifest, thereby enabling arecipient of a stream content object to authenticate the set of streamcontent objects based on the cryptographic signature.
 9. Acomputer-implemented method for reconstructing one or more streamcontent objects that belong to a content stream for downloading acontent collection, comprising: receiving, by a computer, from aprovider of the content collection, an initial set of stream contentobjects belonging to the content stream, wherein a respective streamcontent object from the initial set of stream content objects includes achunk of a stream-construction manifest, wherein the stream-constructionmanifest includes a set of stream-construction rules and a set ofentries corresponding to content components in the content collection;in response to determining that a content component included in thecontent collection exists in a local cache, reconstructing one or morestream content objects for the content component based on the set ofstream-construction rules, wherein a respective stream content objectfrom the one or more reconstructed stream content objects includes achunk of the content component, and wherein the initial set of streamcontent objects and the one or more reconstructed stream content objectshave a same name prefix; and inserting the one or more reconstructedstream content objects into the content stream.
 10. The method of claim9, wherein the set of stream-construction rules includes one or more of:a rule that defines a naming convention for the set of stream contentobjects; a rule that specifies a signing key; and a rule that specifieswhether to include cryptographic signatures for the set of streamcontent objects in the stream-construction manifest.
 11. The method ofclaim 9, further comprising: extracting a global unique identifier(GUID) for the content stream from a foremost stream content object inthe initial set of stream content objects; in response to determiningthat the local cache stores a copy of the stream-construction manifestbased on the extracted GUID, reconstructing a copy of the entire contentstream using content components stored in the local cache; anddelivering the copy of the entire content stream to a requester of thecontent stream.
 12. The method of claim 9, wherein a respective entry inthe stream-construction manifest corresponds to a content componentspanning multiple stream content objects, wherein the entry lists hashvalues of multiple chunks embedded in the multiple stream contentobjects.
 13. The method of claim 12, wherein the stream-constructionmanifest further comprises a cryptographic signature generated over thestream-construction manifest, thereby enabling a recipient of a streamcontent object to authenticate the set of stream content objects basedon the cryptographic signature.
 14. A computer system for reconstructingone or more stream content objects that belong to a content stream fordownloading a content collection, the system comprising: a processor;and a storage device coupled to the processor and storing instructionswhich when executed by the processor cause the processor to perform amethod, the method comprising: receiving, by a computer, from a providerof the content collection, an initial set of stream content objectsbelonging to the content stream, wherein a respective stream contentobject from the initial set of stream content objects includes a chunkof a stream-construction manifest, wherein the stream-constructionmanifest includes a set of stream-construction rules and a set ofentries corresponding to content components in the content collection;in response to determining that a content component included in thecontent collection exists in a local cache, reconstructing one or morestream content objects for the content component based on the set ofstream-construction rules, wherein a respective stream content objectfrom the one or more reconstructed stream content objects includes achunk of the content component, and wherein the initial set of streamcontent objects and the one or more reconstructed stream content objectshave a same name prefix; and inserting the one or more reconstructedstream content objects into the content stream.
 15. The system of claim14, wherein the set of stream-construction rules includes one or moreof: a rule that defines a naming convention for the set of streamcontent objects; a rule that specifies a signing key; and a rule thatspecifies whether to include cryptographic signatures for the set ofstream content objects in the stream-construction manifest.
 16. Thesystem of claim 14, wherein the method further comprises: extracting aglobal unique identifier (GUID) for the content stream from a foremoststream content object in the initial set of stream content objects; inresponse to determining that the local cache stores a copy of thestream-construction manifest based on the extracted GUID, reconstructinga copy of the entire content stream using content components stored inthe local cache; and delivering the copy of the entire content stream toa requester of the content stream.
 17. The system of claim 14, wherein arespective entry in the stream-construction manifest corresponds to acontent component spanning multiple stream content objects, wherein theentry lists hash values of multiple chunks embedded in the multiplestream content objects.
 18. The system of claim 17, wherein thestream-construction manifest further comprises a cryptographic signaturegenerated over the stream-construction manifest, thereby enabling arecipient of a stream content object to authenticate the set of streamcontent objects based on the cryptographic signature.